home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 May / EnigmA AMIGA RUN 18 (1997)(G.R. Edizioni)(IT)[!][issue 1997-05][EAR-CD II].iso / ghost / gs403src_gs.lha / gs4.03 / zusparam.c < prev    next >
C/C++ Source or Header  |  1996-06-22  |  13KB  |  499 lines
  1. /* Copyright (C) 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* zusparam.c */
  20. /* User and system parameter operators */
  21. #include "memory_.h"
  22. #include "string_.h"
  23. #include "ghost.h"
  24. #include "errors.h"
  25. #include "oper.h"
  26. #include "gscdefs.h"
  27. #include "gsstruct.h"        /* for gxht.h */
  28. #include "gsfont.h"        /* for user params */
  29. #include "gxht.h"        /* for user params */
  30. #include "gsutil.h"
  31. #include "estack.h"
  32. #include "ialloc.h"        /* for imemory for status */
  33. #include "idict.h"
  34. #include "idparam.h"
  35. #include "iparam.h"
  36. #include "dstack.h"
  37. #include "iname.h"
  38. #include "iutil2.h"
  39. #include "store.h"
  40.  
  41. /* The (global) font directory */
  42. extern gs_font_dir *ifont_dir;        /* in zfont.c */
  43.  
  44. /* Import the GC parameters from zvmem2.c. */
  45. extern int set_vm_reclaim(P1(long));
  46. extern int set_vm_threshold(P1(long));
  47.  
  48. /* The system passwords. */
  49. private password StartJobPassword = NULL_PASSWORD;
  50. password SystemParamsPassword = NULL_PASSWORD;    /* exported for ziodev2.c. */
  51.  
  52. /* Define an individual user or system parameter. */
  53. /* Eventually this will be made public. */
  54. #define param_def_common\
  55.     const char _ds *pname
  56. typedef struct param_def_s {
  57.     param_def_common;
  58. } param_def;
  59. typedef struct long_param_def_s {
  60.     param_def_common;
  61.     long min_value, max_value;
  62.     long (*current)(P0());
  63.     int (*set)(P1(long));
  64. } long_param_def;
  65. #if arch_sizeof_long > arch_sizeof_int
  66. #  define max_uint_param max_uint
  67. #else
  68. #  define max_uint_param max_long
  69. #endif
  70. typedef struct bool_param_def_s {
  71.     param_def_common;
  72.     bool (*current)(P0());
  73.     int (*set)(P1(bool));
  74. } bool_param_def;
  75. typedef struct string_param_def_s {
  76.     param_def_common;
  77.     void (*current)(P1(gs_param_string *));
  78.     int (*set)(P1(gs_param_string *));
  79. } string_param_def;
  80. /* Define a parameter set (user or system). */
  81. typedef struct param_set_s {
  82.     const long_param_def *long_defs;
  83.       uint long_count;
  84.     const bool_param_def *bool_defs;
  85.       uint bool_count;
  86.     const string_param_def *string_defs;
  87.       uint string_count;
  88. } param_set;
  89.  
  90. /* Forward references */
  91. private int setparams(P2(gs_param_list *, const param_set _ds *));
  92. private int currentparams(P2(os_ptr, const param_set _ds *));
  93.  
  94. /* ------ Passwords ------ */
  95.  
  96. #define plist ((gs_param_list *)&list)
  97.  
  98. /* <string|int> .checkpassword <0|1|2> */
  99. private int
  100. zcheckpassword(register os_ptr op)
  101. {    ref params[2];
  102.     array_param_list list;
  103.     int result = 0;
  104.     int code = name_ref((const byte *)"Password", 8, ¶ms[0], 0);
  105.     if ( code < 0 )
  106.       return code;
  107.     params[1] = *op;
  108.     array_param_list_read(&list, params, 2, NULL, false);
  109.     if ( param_check_password(plist, &StartJobPassword) == 0 )
  110.         result = 1;
  111.     if ( param_check_password(plist, &SystemParamsPassword) == 0 )
  112.         result = 2;
  113.     make_int(op, result);
  114.     return 0;
  115. }
  116.  
  117. #undef plist
  118.  
  119. /* ------ System parameters ------ */
  120.  
  121. /* Integer values */
  122. private long
  123. current_BuildTime(void)
  124. {    return gs_buildtime;
  125. }
  126. private long
  127. current_MaxFontCache(void)
  128. {    return gs_currentcachesize(ifont_dir);
  129. }
  130. private int
  131. set_MaxFontCache(long val)
  132. {    return gs_setcachesize(ifont_dir,
  133.                    (uint)(val < 0 ? 0 : val > max_uint ? max_uint :
  134.                       val));
  135. }
  136. private long
  137. current_CurFontCache(void)
  138. {    uint cstat[7];
  139.     gs_cachestatus(ifont_dir, cstat);
  140.     return cstat[0];
  141. }
  142. private long
  143. current_MaxGlobalVM(void)
  144. {    gs_memory_gc_status_t stat;
  145.     gs_memory_gc_status(iimemory_global, &stat);
  146.     return stat.max_vm;
  147. }
  148. private int
  149. set_MaxGlobalVM(long val)
  150. {    gs_memory_gc_status_t stat;
  151.     gs_memory_gc_status(iimemory_global, &stat);
  152.     stat.max_vm = max(val, 0);
  153.     gs_memory_set_gc_status(iimemory_global, &stat);
  154.     return 0;
  155. }
  156. private long
  157. current_Revision(void)
  158. {    return gs_revision;
  159. }
  160. private const long_param_def system_long_params[] = {
  161.     {"BuildTime", 0, max_uint_param, current_BuildTime, NULL},
  162.     {"MaxFontCache", 0, max_uint_param, current_MaxFontCache, set_MaxFontCache},
  163.     {"CurFontCache", 0, max_uint_param, current_CurFontCache, NULL},
  164.     {"Revision", 0, max_uint_param, current_Revision, NULL},
  165.         /* Extensions */
  166.     {"MaxGlobalVM", 0, max_uint_param, current_MaxGlobalVM, set_MaxGlobalVM}
  167. };
  168. /* Boolean values */
  169. private bool
  170. current_ByteOrder(void)
  171. {    return !arch_is_big_endian;
  172. }
  173. private const bool_param_def system_bool_params[] = {
  174.     {"ByteOrder", current_ByteOrder, NULL}
  175. };
  176. /* String values */
  177. private void
  178. current_RealFormat(gs_param_string *pval)
  179. {
  180. #if arch_floats_are_IEEE
  181.     static const char *rfs = "IEEE";
  182. #else
  183.     static const char *rfs = "not IEEE";
  184. #endif
  185.     pval->data = (const byte *)rfs;
  186.     pval->size = strlen(rfs);
  187.     pval->persistent = true;
  188. }
  189. private const string_param_def system_string_params[] = {
  190.     {"RealFormat", current_RealFormat, NULL}
  191. };
  192.  
  193. /* The system parameter set */
  194. private const param_set system_param_set = {
  195.     system_long_params, countof(system_long_params),
  196.     system_bool_params, countof(system_bool_params),
  197.     system_string_params, countof(system_string_params)
  198. };
  199.  
  200.  
  201. /* <dict> setsystemparams - */
  202. private int
  203. zsetsystemparams(register os_ptr op)
  204. {    int code;
  205.     dict_param_list list;
  206.     password pass;
  207.  
  208.     check_type(*op, t_dictionary);
  209.     code = dict_param_list_read(&list, op, NULL, false);
  210.     if ( code < 0 )
  211.       return code;
  212. #define plist ((gs_param_list *)&list)
  213.     code = param_check_password(plist, &SystemParamsPassword);
  214.     if ( code != 0 )
  215.       return_error(code < 0 ? code : e_invalidaccess);
  216.     code = param_read_password(plist, "StartJobPassword", &pass);
  217.     switch ( code )
  218.     {
  219.     default:            /* invalid */
  220.         return code;
  221.     case 1:                /* missing */
  222.         break;
  223.     case 0:
  224.         StartJobPassword = pass;
  225.     }
  226.     code = param_read_password(plist, "SystemParamsPassword", &pass);
  227.     switch ( code )
  228.     {
  229.     default:            /* invalid */
  230.         return code;
  231.     case 1:                /* missing */
  232.         break;
  233.     case 0:
  234.         SystemParamsPassword = pass;
  235.     }
  236.     code = setparams(plist, &system_param_set);
  237.     if ( code < 0 )
  238.       return code;
  239. #undef plist
  240.     pop(1);
  241.     return 0;
  242. }
  243.  
  244. /* - .currentsystemparams <name1> <value1> ... */
  245. private int
  246. zcurrentsystemparams(os_ptr op)
  247. {    return currentparams(op, &system_param_set);
  248. }
  249.  
  250. /* ------ User parameters ------ */
  251.  
  252. /* Integer values */
  253. private long
  254. current_JobTimeout(void)
  255. {    return 0;
  256. }
  257. private int
  258. set_JobTimeout(long val)
  259. {    return 0;
  260. }
  261. private long
  262. current_MaxFontItem(void)
  263. {    return gs_currentcacheupper(ifont_dir);
  264. }
  265. private int
  266. set_MaxFontItem(long val)
  267. {    return gs_setcacheupper(ifont_dir, val);
  268. }
  269. private long
  270. current_MinFontCompress(void)
  271. {    return gs_currentcachelower(ifont_dir);
  272. }
  273. private int
  274. set_MinFontCompress(long val)
  275. {    return gs_setcachelower(ifont_dir, val);
  276. }
  277. private long
  278. current_MaxOpStack(void)
  279. {    return ref_stack_max_count(&o_stack);
  280. }
  281. private int
  282. set_MaxOpStack(long val)
  283. {    return ref_stack_set_max_count(&o_stack, val);
  284. }
  285. private long
  286. current_MaxDictStack(void)
  287. {    return ref_stack_max_count(&d_stack);
  288. }
  289. private int
  290. set_MaxDictStack(long val)
  291. {    return ref_stack_set_max_count(&d_stack, val);
  292. }
  293. private long
  294. current_MaxExecStack(void)
  295. {    return ref_stack_max_count(&e_stack);
  296. }
  297. private int
  298. set_MaxExecStack(long val)
  299. {    return ref_stack_set_max_count(&e_stack, val);
  300. }
  301. private long
  302. current_MaxLocalVM(void)
  303. {    gs_memory_gc_status_t stat;
  304.     gs_memory_gc_status(iimemory_local, &stat);
  305.     return stat.max_vm;
  306. }
  307. private int
  308. set_MaxLocalVM(long val)
  309. {    gs_memory_gc_status_t stat;
  310.     gs_memory_gc_status(iimemory_local, &stat);
  311.     stat.max_vm = max(val, 0);
  312.     gs_memory_set_gc_status(iimemory_local, &stat);
  313.     return 0;
  314. }
  315. private long
  316. current_VMReclaim(void)
  317. {    gs_memory_gc_status_t gstat, lstat;
  318.     gs_memory_gc_status(iimemory_global, &gstat);
  319.     gs_memory_gc_status(iimemory_local, &lstat);
  320.     return (!gstat.enabled ? -2 : !lstat.enabled ? -1 : 0);
  321. }
  322. private long
  323. current_VMThreshold(void)
  324. {    gs_memory_gc_status_t stat;
  325.     gs_memory_gc_status(iimemory_local, &stat);
  326.     return stat.vm_threshold;
  327. }
  328. #define current_WaitTimeout current_JobTimeout
  329. #define set_WaitTimeout set_JobTimeout
  330. private const long_param_def user_long_params[] = {
  331.     {"JobTimeout", 0, max_uint_param,
  332.        current_JobTimeout, set_JobTimeout},
  333.     {"MaxFontItem", 0, max_uint_param,
  334.        current_MaxFontItem, set_MaxFontItem},
  335.     {"MinFontCompress", 0, max_uint_param,
  336.        current_MinFontCompress, set_MinFontCompress},
  337.     {"MaxOpStack", 0, max_uint_param,
  338.        current_MaxOpStack, set_MaxOpStack},
  339.     {"MaxDictStack", 0, max_uint_param,
  340.        current_MaxDictStack, set_MaxDictStack},
  341.     {"MaxExecStack", 0, max_uint_param,
  342.        current_MaxExecStack, set_MaxExecStack},
  343.     {"MaxLocalVM", 0, max_uint_param,
  344.        current_MaxLocalVM, set_MaxLocalVM},
  345.     {"VMReclaim", -2, 0,
  346.        current_VMReclaim, set_vm_reclaim},
  347.     {"VMThreshold", 0, max_uint_param,
  348.        current_VMThreshold, set_vm_threshold},
  349.     {"WaitTimeout", 0, max_uint_param,
  350.        current_WaitTimeout, set_WaitTimeout}
  351. };
  352. /* Boolean values */
  353. private bool
  354. current_AccurateScreens(void)
  355. {    return gs_currentaccuratescreens();
  356. }
  357. private int
  358. set_AccurateScreens(bool val)
  359. {    gs_setaccuratescreens(val);
  360.     return 0;
  361. }
  362. private const bool_param_def user_bool_params[] = {
  363.     {"AccurateScreens", current_AccurateScreens, set_AccurateScreens}
  364. };
  365. /* String values */
  366. private void
  367. current_JobName(gs_param_string *pval)
  368. {    pval->data = 0;
  369.     pval->size = 0;
  370.     pval->persistent = true;
  371. }
  372. private int
  373. set_JobName(gs_param_string *val)
  374. {    return 0;
  375. }
  376. private const string_param_def user_string_params[] = {
  377.     {"JobName", current_JobName, set_JobName}
  378. };
  379.  
  380. /* The user parameter set */
  381. private const param_set user_param_set = {
  382.     user_long_params, countof(user_long_params),
  383.     user_bool_params, countof(user_bool_params),
  384.     user_string_params, countof(user_string_params)
  385. };
  386.  
  387. /* <dict> setuserparams - */
  388. private int
  389. zsetuserparams(register os_ptr op)
  390. {    dict_param_list list;
  391.     int code;
  392.  
  393.     check_type(*op, t_dictionary);
  394.     code = dict_param_list_read(&list, op, NULL, false);
  395.     if ( code < 0 )
  396.       return code;
  397.     code = setparams((gs_param_list *)&list, &user_param_set);
  398.     if ( code < 0 )
  399.       return code;
  400.     pop(1);
  401.     return 0;
  402. }
  403.  
  404. /* - .currentuserparams <name1> <value1> ... */
  405. private int
  406. zcurrentuserparams(os_ptr op)
  407. {    return currentparams(op, &user_param_set);
  408. }
  409.  
  410. /* ------ Initialization procedure ------ */
  411.  
  412. BEGIN_OP_DEFS(zusparam_op_defs) {
  413.         /* User and system parameters are readable even in Level 1. */
  414.     {"0.currentsystemparams", zcurrentsystemparams},
  415.     {"0.currentuserparams", zcurrentuserparams},
  416.         /* The rest of the operators are defined only in Level 2. */
  417.         op_def_begin_level2(),
  418.     {"1.checkpassword", zcheckpassword},
  419.     {"1setsystemparams", zsetsystemparams},
  420.     {"1setuserparams", zsetuserparams},
  421. END_OP_DEFS(0) }
  422.  
  423. /* ------ Internal procedures ------ */
  424.  
  425. /* Set the values of a parameter set from a parameter list. */
  426. /* We don't attempt to back out if anything fails. */
  427. private int
  428. setparams(gs_param_list *plist, const param_set _ds *pset)
  429. {    int i, code;
  430.     for ( i = 0; i < pset->long_count; i++ )
  431.       {    const long_param_def *pdef = &pset->long_defs[i];
  432.         long val;
  433.         if ( pdef->set == NULL )
  434.           continue;
  435.         code = param_read_long(plist, pdef->pname, &val);
  436.         switch ( code )
  437.           {
  438.           default:            /* invalid */
  439.             return code;
  440.           case 1:            /* missing */
  441.             break;
  442.           case 0:
  443.             if ( val < pdef->min_value || val > pdef->max_value )
  444.               return_error(e_rangecheck);
  445.             code = (*pdef->set)(val);
  446.             if ( code < 0 )
  447.               return code;
  448.           }
  449.       }
  450.     for ( i = 0; i < pset->bool_count; i++ )
  451.       {    const bool_param_def *pdef = &pset->bool_defs[i];
  452.         bool val;
  453.         if ( pdef->set == NULL )
  454.           continue;
  455.         code = param_read_bool(plist, pdef->pname, &val);
  456.         if ( code == 0 )
  457.           code = (*pdef->set)(val);
  458.         if ( code < 0 )
  459.           return code;
  460.       }
  461.     /****** WE SHOULD DO STRINGS AND STRING ARRAYS, BUT WE DON'T YET ******/
  462.     return 0;
  463. }
  464.  
  465. /* Get the current values of a parameter set to the stack. */
  466. private int
  467. currentparams(os_ptr op, const param_set _ds *pset)
  468. {    stack_param_list list;
  469.     int i;
  470.     stack_param_list_write(&list, &o_stack, NULL);
  471.     for ( i = 0; i < pset->long_count; i++ )
  472.     {    long val = (*pset->long_defs[i].current)();
  473.         int code = param_write_long((gs_param_list *)&list,
  474.                         pset->long_defs[i].pname, &val);
  475.  
  476.         if ( code < 0 )
  477.           return code;
  478.     }
  479.     for ( i = 0; i < pset->bool_count; i++ )
  480.     {    bool val = (*pset->bool_defs[i].current)();
  481.         int code = param_write_bool((gs_param_list *)&list,
  482.                         pset->bool_defs[i].pname, &val);
  483.  
  484.         if ( code < 0 )
  485.           return code;
  486.     }
  487.     for ( i = 0; i < pset->string_count; i++ )
  488.     {    gs_param_string val;
  489.         int code;
  490.  
  491.         (*pset->string_defs[i].current)(&val);
  492.         code = param_write_string((gs_param_list *)&list,
  493.                       pset->string_defs[i].pname, &val);
  494.         if ( code < 0 )
  495.           return code;
  496.     }
  497.     return 0;
  498. }
  499.